home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / kevoSource / memory.h < prev    next >
Text File  |  1993-05-11  |  3KB  |  88 lines
  1. /* Kevo -- a prototype-based object-oriented language */
  2. /* (c) Antero Taivalsaari 1991-1993                   */
  3. /* Some parts (c) Antero Taivalsaari 1986-1988           */
  4. /* memory.h: Memory and object management structures and internals */
  5.  
  6. /* Memory allocation internals */
  7.  
  8. char*     mymalloc();
  9. char*    mycalloc();
  10. char*    myrealloc();
  11. char*    allocStrCpy();
  12.  
  13.  
  14. /* Object structures and internals */
  15.  
  16. /* 
  17.     Note that in Kevo files the term 'object' has two meanings:
  18.  
  19. 1)    The plain term 'object' usually refers to a structure which
  20.     is composed of a handle and a store. The struct 'OBJECT*' is thus
  21.     actually a pointer to a handle, rather than an object in the 
  22.     object-oriented sense. The handle structure is called OBJECT, and
  23.     the data part STORE.
  24.     
  25.     OBJECT structures may be of two basic kinds:
  26.         - 'primitive' is a special kind of OBJECT whose size field is 0
  27.           and which refers to an executable C function (no STORE part).
  28.          - 'closure' is an OBJECT which contains executable threaded code
  29.            in its STORE part. The threaded code may be a real operation,
  30.            or then e.g. be a variable and load some data to data
  31.            stacks. The data are stored within the threaded code itself.
  32.  
  33.     Since OBJECT is a two-level structure, the size of the STORE part
  34.     can be changed dynamically (primitives cannot be resized, though).
  35.     
  36. 2)    In some places we speak of "object-oriented objects". This term refers
  37.     to a special kind of 'OBJECT' which refers to a 'CONTEXT' structure.
  38.     Context is a name space, i.e. a mapping from names (called PAIRs) to
  39.     OBJECTs. It serves as the implementation-level equivalent of truly
  40.     object-oriented objects.
  41.  
  42.     Note that the self-reference in Kevo is a pointer to OBJECT. Not all
  43.     OBJECTs can however receive messages.
  44. */ 
  45.  
  46.  
  47. /* IMPORTANT: 'mfa should always be the first field in 'objectStruct'. */
  48. /* 
  49.     References such as '(*up)->priority' are based on the fact that the offset
  50.     to store parts is zero. 
  51. */
  52.  
  53. typedef struct objectStruct     OBJECT; 
  54. typedef struct storageStruct     STORE;
  55.  
  56. struct objectStruct {
  57.     STORE*    mfa;    /* Memory pointer (memory field address) */
  58.     int        sfa;    /* Object size (size field address) */
  59. };
  60.  
  61.  
  62. /* Inlined for speed */
  63. #define        createStore(size)    ((STORE*)mycalloc(1, (size)*CELL))
  64.  
  65. OBJECT*        createPrimitive();
  66. OBJECT*        createClosure();
  67. OBJECT*        copyObject();
  68. void        deleteObject();
  69. void        resizeClosure();
  70.  
  71. int            recognizeObject();
  72.  
  73.  
  74. /* 
  75.   Store is a structure whose size may grow and shrink dynamically.
  76.  
  77.   Primitive (C code) objects do not have a store field, but the address of
  78.   the C operation is stored directly in the 'mfa' field of the object.
  79.   The size field of a primitive object is always 0 to differentiate such
  80.   objects from other kinds of objects.
  81. */
  82.  
  83. struct  storageStruct {
  84.     int*    efa;    /* Execution field (execution field address) */
  85.     int*    pfa;     /* Parameter field (parameter field address) */
  86. };
  87.  
  88.